package o;

import android.content.Context;
import android.content.res.TypedArray;
import android.os.Build.VERSION;
import android.util.AttributeSet;
import android.util.Log;
import android.util.SparseIntArray;
import android.util.Xml;
import android.view.View;
import android.view.ViewGroup;
import androidx.constraintlayout.widget.Barrier;
import androidx.constraintlayout.widget.ConstraintHelper;
import androidx.constraintlayout.widget.ConstraintLayout;
import androidx.constraintlayout.widget.Constraints;
import androidx.constraintlayout.widget.Constraints.LayoutParams;
import androidx.constraintlayout.widget.Guideline;
import com.huawei.appgallery.festivalanimation.particle.modifiers.SizeModifier;
import java.io.IOException;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import o.fc.c;
import o.fc.e;
import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserException;

public class fb {
    private static final int[] ˋ = new int[]{0, 4, 8};
    private static SparseIntArray ॱ = new SparseIntArray();
    private HashMap<Integer, b> ˊ = new HashMap();

    static class b {
        public float ʹ;
        public int ʻ;
        public int ʻˊ;
        public int ʻˋ;
        public int ʻॱ;
        public int ʻᐝ;
        public int ʼ;
        public int ʼˊ;
        public boolean ʼˋ;
        public String ʼॱ;
        public float ʼᐝ;
        public int ʽ;
        public int ʽˊ;
        public boolean ʽˋ;
        public int ʽॱ;
        public float ʽᐝ;
        public float ʾ;
        public int ʾॱ;
        public float ʿ;
        public String ʿॱ;
        public int ˈ;
        public float ˉ;
        public int[] ˉॱ;
        public int ˊ;
        public int ˊʻ;
        public int ˊʼ;
        public int ˊˊ;
        public int ˊˋ;
        public int ˊॱ;
        public int ˊᐝ;
        int ˋ;
        public int ˋˊ;
        public int ˋˋ;
        public int ˋॱ;
        public int ˋᐝ;
        public int ˌ;
        public int ˍ;
        boolean ˎ;
        public int ˎˎ;
        public int ˎˏ;
        public int ˏ;
        public int ˏˎ;
        public int ˏˏ;
        public int ˏॱ;
        public int ˑ;
        public int ͺ;
        public int ͺॱ;
        public int ـ;
        public int ॱ;
        public int ॱʻ;
        public float ॱʼ;
        public float ॱʽ;
        public int ॱˊ;
        public int ॱˋ;
        public int ॱˎ;
        public int ॱͺ;
        public float ॱॱ;
        public int ॱᐝ;
        public int ᐝ;
        public float ᐝˊ;
        public float ᐝˋ;
        public int ᐝॱ;
        public float ᐝᐝ;
        public boolean ᐧ;
        public int ᐨ;
        public float ᶥ;
        public float ㆍ;
        public float ꓸ;
        public float ꜞ;
        public float ꜟ;
        public float ꞌ;
        public float ﹳ;
        public boolean ﾞ;
        public float ﾟ;

        private b() {
            this.ˎ = false;
            this.ˊ = -1;
            this.ᐝ = -1;
            this.ॱॱ = SizeModifier.STABLE_STATE_SCALE;
            this.ʻ = -1;
            this.ʽ = -1;
            this.ʼ = -1;
            this.ͺ = -1;
            this.ˊॱ = -1;
            this.ˋॱ = -1;
            this.ॱˊ = -1;
            this.ˏॱ = -1;
            this.ॱˋ = -1;
            this.ʻॱ = -1;
            this.ॱᐝ = -1;
            this.ॱˎ = -1;
            this.ᐝॱ = -1;
            this.ʾ = 0.5f;
            this.ʿ = 0.5f;
            this.ʼॱ = null;
            this.ʽॱ = -1;
            this.ˈ = 0;
            this.ˉ = 0.0f;
            this.ˊˊ = -1;
            this.ˊˋ = -1;
            this.ˋˊ = -1;
            this.ˊᐝ = -1;
            this.ˎˎ = -1;
            this.ˌ = -1;
            this.ˍ = -1;
            this.ˋˋ = -1;
            this.ˋᐝ = -1;
            this.ˏˏ = 0;
            this.ˎˏ = -1;
            this.ˑ = -1;
            this.ͺॱ = -1;
            this.ˏˎ = -1;
            this.ـ = -1;
            this.ॱͺ = -1;
            this.ॱʽ = 0.0f;
            this.ॱʼ = 0.0f;
            this.ॱʻ = 0;
            this.ᐨ = 0;
            this.ᐝᐝ = 1.0f;
            this.ᐧ = false;
            this.ᐝˋ = 0.0f;
            this.ᐝˊ = 0.0f;
            this.ꜟ = 0.0f;
            this.ᶥ = 0.0f;
            this.ꓸ = 1.0f;
            this.ꜞ = 1.0f;
            this.ㆍ = Float.NaN;
            this.ꞌ = Float.NaN;
            this.ﹳ = 0.0f;
            this.ʹ = 0.0f;
            this.ﾟ = 0.0f;
            this.ﾞ = false;
            this.ʼˋ = false;
            this.ʻˊ = 0;
            this.ʼˊ = 0;
            this.ʻᐝ = -1;
            this.ʻˋ = -1;
            this.ʽˊ = -1;
            this.ʾॱ = -1;
            this.ʼᐝ = 1.0f;
            this.ʽᐝ = 1.0f;
            this.ʽˋ = false;
            this.ˊʻ = -1;
            this.ˊʼ = -1;
        }

        public /* synthetic */ Object clone() throws CloneNotSupportedException {
            return ˋ();
        }

        public b ˋ() {
            b bVar = new b();
            bVar.ˎ = this.ˎ;
            bVar.ˏ = this.ˏ;
            bVar.ॱ = this.ॱ;
            bVar.ˊ = this.ˊ;
            bVar.ᐝ = this.ᐝ;
            bVar.ॱॱ = this.ॱॱ;
            bVar.ʻ = this.ʻ;
            bVar.ʽ = this.ʽ;
            bVar.ʼ = this.ʼ;
            bVar.ͺ = this.ͺ;
            bVar.ˊॱ = this.ˊॱ;
            bVar.ˋॱ = this.ˋॱ;
            bVar.ॱˊ = this.ॱˊ;
            bVar.ˏॱ = this.ˏॱ;
            bVar.ॱˋ = this.ॱˋ;
            bVar.ʻॱ = this.ʻॱ;
            bVar.ॱᐝ = this.ॱᐝ;
            bVar.ॱˎ = this.ॱˎ;
            bVar.ᐝॱ = this.ᐝॱ;
            bVar.ʾ = this.ʾ;
            bVar.ʿ = this.ʿ;
            bVar.ʼॱ = this.ʼॱ;
            bVar.ˊˊ = this.ˊˊ;
            bVar.ˊˋ = this.ˊˋ;
            bVar.ʾ = this.ʾ;
            bVar.ʾ = this.ʾ;
            bVar.ʾ = this.ʾ;
            bVar.ʾ = this.ʾ;
            bVar.ʾ = this.ʾ;
            bVar.ˋˊ = this.ˋˊ;
            bVar.ˊᐝ = this.ˊᐝ;
            bVar.ˎˎ = this.ˎˎ;
            bVar.ˌ = this.ˌ;
            bVar.ˍ = this.ˍ;
            bVar.ˋˋ = this.ˋˋ;
            bVar.ˋᐝ = this.ˋᐝ;
            bVar.ˏˏ = this.ˏˏ;
            bVar.ˎˏ = this.ˎˏ;
            bVar.ˑ = this.ˑ;
            bVar.ͺॱ = this.ͺॱ;
            bVar.ˏˎ = this.ˏˎ;
            bVar.ـ = this.ـ;
            bVar.ॱͺ = this.ॱͺ;
            bVar.ॱʽ = this.ॱʽ;
            bVar.ॱʼ = this.ॱʼ;
            bVar.ॱʻ = this.ॱʻ;
            bVar.ᐨ = this.ᐨ;
            bVar.ᐝᐝ = this.ᐝᐝ;
            bVar.ᐧ = this.ᐧ;
            bVar.ᐝˋ = this.ᐝˋ;
            bVar.ᐝˊ = this.ᐝˊ;
            bVar.ꜟ = this.ꜟ;
            bVar.ᶥ = this.ᶥ;
            bVar.ꓸ = this.ꓸ;
            bVar.ꜞ = this.ꜞ;
            bVar.ㆍ = this.ㆍ;
            bVar.ꞌ = this.ꞌ;
            bVar.ﹳ = this.ﹳ;
            bVar.ʹ = this.ʹ;
            bVar.ﾟ = this.ﾟ;
            bVar.ﾞ = this.ﾞ;
            bVar.ʼˋ = this.ʼˋ;
            bVar.ʻˊ = this.ʻˊ;
            bVar.ʼˊ = this.ʼˊ;
            bVar.ʻᐝ = this.ʻᐝ;
            bVar.ʻˋ = this.ʻˋ;
            bVar.ʽˊ = this.ʽˊ;
            bVar.ʾॱ = this.ʾॱ;
            bVar.ʼᐝ = this.ʼᐝ;
            bVar.ʽᐝ = this.ʽᐝ;
            bVar.ˊʻ = this.ˊʻ;
            bVar.ˊʼ = this.ˊʼ;
            if (this.ˉॱ != null) {
                bVar.ˉॱ = Arrays.copyOf(this.ˉॱ, this.ˉॱ.length);
            }
            bVar.ʽॱ = this.ʽॱ;
            bVar.ˈ = this.ˈ;
            bVar.ˉ = this.ˉ;
            bVar.ʽˋ = this.ʽˋ;
            return bVar;
        }

        private void ˊ(ConstraintHelper constraintHelper, int i, LayoutParams layoutParams) {
            ˏ(i, layoutParams);
            if (constraintHelper instanceof Barrier) {
                this.ˊʼ = 1;
                Barrier barrier = (Barrier) constraintHelper;
                this.ˊʻ = barrier.ˋ();
                this.ˉॱ = barrier.ˏ();
            }
        }

        private void ˏ(int i, LayoutParams layoutParams) {
            ॱ(i, layoutParams);
            this.ᐝᐝ = layoutParams.ʾॱ;
            this.ᐝˊ = layoutParams.ʽᐝ;
            this.ꜟ = layoutParams.ʽˋ;
            this.ᶥ = layoutParams.ʿॱ;
            this.ꓸ = layoutParams.ˉॱ;
            this.ꜞ = layoutParams.ˊʻ;
            this.ㆍ = layoutParams.ˊʼ;
            this.ꞌ = layoutParams.ˈॱ;
            this.ﹳ = layoutParams.ˊʽ;
            this.ʹ = layoutParams.ˌॱ;
            this.ﾟ = layoutParams.ˋʼ;
            this.ᐝˋ = layoutParams.ʽˊ;
            this.ᐧ = layoutParams.ʼᐝ;
        }

        private void ॱ(int i, ConstraintLayout.LayoutParams layoutParams) {
            this.ˋ = i;
            this.ʻ = layoutParams.ˏ;
            this.ʽ = layoutParams.ˋ;
            this.ʼ = layoutParams.ᐝ;
            this.ͺ = layoutParams.ʽ;
            this.ˊॱ = layoutParams.ॱॱ;
            this.ˋॱ = layoutParams.ʻ;
            this.ॱˊ = layoutParams.ʼ;
            this.ˏॱ = layoutParams.ˊॱ;
            this.ॱˋ = layoutParams.ͺ;
            this.ʻॱ = layoutParams.ॱᐝ;
            this.ॱᐝ = layoutParams.ॱˋ;
            this.ॱˎ = layoutParams.ᐝॱ;
            this.ᐝॱ = layoutParams.ॱˎ;
            this.ʾ = layoutParams.ˋˊ;
            this.ʿ = layoutParams.ˊᐝ;
            this.ʼॱ = layoutParams.ˊˋ;
            this.ʽॱ = layoutParams.ˋॱ;
            this.ˈ = layoutParams.ॱˊ;
            this.ˉ = layoutParams.ˏॱ;
            this.ˊˊ = layoutParams.ॱʽ;
            this.ˊˋ = layoutParams.ॱʻ;
            this.ˋˊ = layoutParams.ـ;
            this.ॱॱ = layoutParams.ˎ;
            this.ˊ = layoutParams.ॱ;
            this.ᐝ = layoutParams.ˊ;
            this.ˏ = layoutParams.width;
            this.ॱ = layoutParams.height;
            this.ˊᐝ = layoutParams.leftMargin;
            this.ˎˎ = layoutParams.rightMargin;
            this.ˌ = layoutParams.topMargin;
            this.ˍ = layoutParams.bottomMargin;
            this.ॱʽ = layoutParams.ˌ;
            this.ॱʼ = layoutParams.ˎˎ;
            this.ᐨ = layoutParams.ˍ;
            this.ॱʻ = layoutParams.ˋᐝ;
            this.ﾞ = layoutParams.ᐧ;
            this.ʼˋ = layoutParams.ᐝˋ;
            this.ʻˊ = layoutParams.ˋˋ;
            this.ʼˊ = layoutParams.ˎˏ;
            this.ﾞ = layoutParams.ᐧ;
            this.ʻᐝ = layoutParams.ˏˏ;
            this.ʻˋ = layoutParams.ͺॱ;
            this.ʽˊ = layoutParams.ˑ;
            this.ʾॱ = layoutParams.ˏˎ;
            this.ʼᐝ = layoutParams.ॱͺ;
            this.ʽᐝ = layoutParams.ॱʼ;
            if (VERSION.SDK_INT >= 17) {
                this.ˋˋ = layoutParams.getMarginEnd();
                this.ˋᐝ = layoutParams.getMarginStart();
            }
        }

        public void ˋ(ConstraintLayout.LayoutParams layoutParams) {
            layoutParams.ˏ = this.ʻ;
            layoutParams.ˋ = this.ʽ;
            layoutParams.ᐝ = this.ʼ;
            layoutParams.ʽ = this.ͺ;
            layoutParams.ॱॱ = this.ˊॱ;
            layoutParams.ʻ = this.ˋॱ;
            layoutParams.ʼ = this.ॱˊ;
            layoutParams.ˊॱ = this.ˏॱ;
            layoutParams.ͺ = this.ॱˋ;
            layoutParams.ॱᐝ = this.ʻॱ;
            layoutParams.ॱˋ = this.ॱᐝ;
            layoutParams.ᐝॱ = this.ॱˎ;
            layoutParams.ॱˎ = this.ᐝॱ;
            layoutParams.leftMargin = this.ˊᐝ;
            layoutParams.rightMargin = this.ˎˎ;
            layoutParams.topMargin = this.ˌ;
            layoutParams.bottomMargin = this.ˍ;
            layoutParams.ʾ = this.ॱͺ;
            layoutParams.ʿ = this.ـ;
            layoutParams.ˋˊ = this.ʾ;
            layoutParams.ˊᐝ = this.ʿ;
            layoutParams.ˋॱ = this.ʽॱ;
            layoutParams.ॱˊ = this.ˈ;
            layoutParams.ˏॱ = this.ˉ;
            layoutParams.ˊˋ = this.ʼॱ;
            layoutParams.ॱʽ = this.ˊˊ;
            layoutParams.ॱʻ = this.ˊˋ;
            layoutParams.ˌ = this.ॱʽ;
            layoutParams.ˎˎ = this.ॱʼ;
            layoutParams.ˍ = this.ᐨ;
            layoutParams.ˋᐝ = this.ॱʻ;
            layoutParams.ᐧ = this.ﾞ;
            layoutParams.ᐝˋ = this.ʼˋ;
            layoutParams.ˋˋ = this.ʻˊ;
            layoutParams.ˎˏ = this.ʼˊ;
            layoutParams.ˏˏ = this.ʻᐝ;
            layoutParams.ͺॱ = this.ʻˋ;
            layoutParams.ˑ = this.ʽˊ;
            layoutParams.ˏˎ = this.ʾॱ;
            layoutParams.ॱͺ = this.ʼᐝ;
            layoutParams.ॱʼ = this.ʽᐝ;
            layoutParams.ـ = this.ˋˊ;
            layoutParams.ˎ = this.ॱॱ;
            layoutParams.ॱ = this.ˊ;
            layoutParams.ˊ = this.ᐝ;
            layoutParams.width = this.ˏ;
            layoutParams.height = this.ॱ;
            if (VERSION.SDK_INT >= 17) {
                layoutParams.setMarginStart(this.ˋᐝ);
                layoutParams.setMarginEnd(this.ˋˋ);
            }
            layoutParams.ॱ();
        }
    }

    static {
        ॱ.append(c.ᐝʼ, 25);
        ॱ.append(c.ᐝʽ, 26);
        ॱ.append(c.ᵎ, 29);
        ॱ.append(c.ᵔ, 30);
        ॱ.append(c.ᶫ, 36);
        ॱ.append(c.ㆍॱ, 35);
        ॱ.append(c.ॱˌ, 4);
        ॱ.append(c.ॱʾ, 3);
        ॱ.append(c.ߵ, 1);
        ॱ.append(c.ﾟॱ, 6);
        ॱ.append(c.ﹶ, 7);
        ॱ.append(c.ॱㆍ, 17);
        ॱ.append(c.ॱᶥ, 18);
        ॱ.append(c.ॱᐧ, 19);
        ॱ.append(c.ʻˋ, 27);
        ॱ.append(c.ᴵ, 32);
        ॱ.append(c.ᵢ, 33);
        ॱ.append(c.ॱᐨ, 10);
        ॱ.append(c.ॱꓸ, 9);
        ॱ.append(c.ﹺ, 13);
        ॱ.append(c.ʻʻ, 16);
        ॱ.append(c.ʻʽ, 14);
        ॱ.append(c.ʳ, 11);
        ॱ.append(c.ʴ, 15);
        ॱ.append(c.ﾞॱ, 12);
        ॱ.append(c.ꞌॱ, 40);
        ॱ.append(c.ᐝʻ, 39);
        ॱ.append(c.ॱﾟ, 41);
        ॱ.append(c.ꓸॱ, 42);
        ॱ.append(c.ॱꜞ, 20);
        ॱ.append(c.ᶥॱ, 37);
        ॱ.append(c.ॱـ, 5);
        ॱ.append(c.ᐧॱ, 75);
        ॱ.append(c.ⁱ, 75);
        ॱ.append(c.ᐨॱ, 75);
        ॱ.append(c.ॱˈ, 75);
        ॱ.append(c.ߺ, 75);
        ॱ.append(c.ʽˊ, 24);
        ॱ.append(c.ˈॱ, 28);
        ॱ.append(c.ͺˏ, 31);
        ॱ.append(c.ͺˎ, 8);
        ॱ.append(c.ʿॱ, 34);
        ॱ.append(c.ˊʼ, 2);
        ॱ.append(c.ʽˋ, 23);
        ॱ.append(c.ʾॱ, 21);
        ॱ.append(c.ʼᐝ, 22);
        ॱ.append(c.ˊʻ, 43);
        ॱ.append(c.ՙ, 44);
        ॱ.append(c.ˎͺ, 45);
        ॱ.append(c.ˑॱ, 46);
        ॱ.append(c.ˏͺ, 60);
        ॱ.append(c.ˊʽ, 47);
        ॱ.append(c.ˋʽ, 48);
        ॱ.append(c.ˉॱ, 49);
        ॱ.append(c.ˋʻ, 50);
        ॱ.append(c.ˌॱ, 51);
        ॱ.append(c.ˋʼ, 52);
        ॱ.append(c.ߴ, 53);
        ॱ.append(c.ꜞॱ, 54);
        ॱ.append(c.ॱꜟ, 55);
        ॱ.append(c.ꜟॱ, 56);
        ॱ.append(c.ॱﾞ, 57);
        ॱ.append(c.ꜝ, 58);
        ॱ.append(c.ॱꞌ, 59);
        ॱ.append(c.ॱˑ, 61);
        ॱ.append(c.ॱˉ, 62);
        ॱ.append(c.ॱˍ, 63);
        ॱ.append(c.ʽᐝ, 38);
        ॱ.append(c.ﹳॱ, 69);
        ॱ.append(c.ॱﹳ, 70);
        ॱ.append(c.י, 71);
        ॱ.append(c.ـॱ, 72);
        ॱ.append(c.ॱʿ, 73);
        ॱ.append(c.ٴ, 74);
    }

    public void ˊ(ConstraintLayout constraintLayout) {
        int childCount = constraintLayout.getChildCount();
        this.ˊ.clear();
        for (int i = 0; i < childCount; i++) {
            View childAt = constraintLayout.getChildAt(i);
            ConstraintLayout.LayoutParams layoutParams = (ConstraintLayout.LayoutParams) childAt.getLayoutParams();
            int id = childAt.getId();
            if (id == -1) {
                throw new RuntimeException("All children of ConstraintLayout must have ids to use ConstraintSet");
            }
            if (!this.ˊ.containsKey(Integer.valueOf(id))) {
                this.ˊ.put(Integer.valueOf(id), new b());
            }
            b bVar = (b) this.ˊ.get(Integer.valueOf(id));
            bVar.ॱ(id, layoutParams);
            bVar.ˏˏ = childAt.getVisibility();
            if (VERSION.SDK_INT >= 17) {
                bVar.ᐝᐝ = childAt.getAlpha();
                bVar.ᐝˊ = childAt.getRotation();
                bVar.ꜟ = childAt.getRotationX();
                bVar.ᶥ = childAt.getRotationY();
                bVar.ꓸ = childAt.getScaleX();
                bVar.ꜞ = childAt.getScaleY();
                float pivotX = childAt.getPivotX();
                float pivotY = childAt.getPivotY();
                if (!(((double) pivotX) == 0.0d && ((double) pivotY) == 0.0d)) {
                    bVar.ㆍ = pivotX;
                    bVar.ꞌ = pivotY;
                }
                bVar.ﹳ = childAt.getTranslationX();
                bVar.ʹ = childAt.getTranslationY();
                if (VERSION.SDK_INT >= 21) {
                    bVar.ﾟ = childAt.getTranslationZ();
                    if (bVar.ᐧ) {
                        bVar.ᐝˋ = childAt.getElevation();
                    }
                }
            }
            if (childAt instanceof Barrier) {
                Barrier barrier = (Barrier) childAt;
                bVar.ʽˋ = barrier.ˊ();
                bVar.ˉॱ = barrier.ˏ();
                bVar.ˊʻ = barrier.ˋ();
            }
        }
    }

    public void ˏ(Constraints constraints) {
        int childCount = constraints.getChildCount();
        this.ˊ.clear();
        for (int i = 0; i < childCount; i++) {
            View childAt = constraints.getChildAt(i);
            LayoutParams layoutParams = (LayoutParams) childAt.getLayoutParams();
            int id = childAt.getId();
            if (id == -1) {
                throw new RuntimeException("All children of ConstraintLayout must have ids to use ConstraintSet");
            }
            if (!this.ˊ.containsKey(Integer.valueOf(id))) {
                this.ˊ.put(Integer.valueOf(id), new b());
            }
            b bVar = (b) this.ˊ.get(Integer.valueOf(id));
            if (childAt instanceof ConstraintHelper) {
                bVar.ˊ((ConstraintHelper) childAt, id, layoutParams);
            }
            bVar.ˏ(id, layoutParams);
        }
    }

    public void ˋ(ConstraintLayout constraintLayout) {
        ˏ(constraintLayout);
        constraintLayout.setConstraintSet(null);
    }

    public void ˏ(ConstraintLayout constraintLayout) {
        int childCount = constraintLayout.getChildCount();
        HashSet hashSet = new HashSet(this.ˊ.keySet());
        for (int i = 0; i < childCount; i++) {
            View childAt = constraintLayout.getChildAt(i);
            int id = childAt.getId();
            if (id == -1) {
                throw new RuntimeException("All children of ConstraintLayout must have ids to use ConstraintSet");
            }
            if (this.ˊ.containsKey(Integer.valueOf(id))) {
                hashSet.remove(Integer.valueOf(id));
                b bVar = (b) this.ˊ.get(Integer.valueOf(id));
                if (childAt instanceof Barrier) {
                    bVar.ˊʼ = 1;
                }
                if (bVar.ˊʼ != -1) {
                    switch (bVar.ˊʼ) {
                        case 1:
                            View view = (Barrier) childAt;
                            view.setId(id);
                            view.setType(bVar.ˊʻ);
                            view.setAllowsGoneWidget(bVar.ʽˋ);
                            if (bVar.ˉॱ == null) {
                                if (bVar.ʿॱ != null) {
                                    bVar.ˉॱ = ˊ(view, bVar.ʿॱ);
                                    view.setReferencedIds(bVar.ˉॱ);
                                    break;
                                }
                            }
                            view.setReferencedIds(bVar.ˉॱ);
                            break;
                            break;
                    }
                }
                ConstraintLayout.LayoutParams layoutParams = (ConstraintLayout.LayoutParams) childAt.getLayoutParams();
                bVar.ˋ(layoutParams);
                childAt.setLayoutParams(layoutParams);
                childAt.setVisibility(bVar.ˏˏ);
                if (VERSION.SDK_INT >= 17) {
                    childAt.setAlpha(bVar.ᐝᐝ);
                    childAt.setRotation(bVar.ᐝˊ);
                    childAt.setRotationX(bVar.ꜟ);
                    childAt.setRotationY(bVar.ᶥ);
                    childAt.setScaleX(bVar.ꓸ);
                    childAt.setScaleY(bVar.ꜞ);
                    if (!Float.isNaN(bVar.ㆍ)) {
                        childAt.setPivotX(bVar.ㆍ);
                    }
                    if (!Float.isNaN(bVar.ꞌ)) {
                        childAt.setPivotY(bVar.ꞌ);
                    }
                    childAt.setTranslationX(bVar.ﹳ);
                    childAt.setTranslationY(bVar.ʹ);
                    if (VERSION.SDK_INT >= 21) {
                        childAt.setTranslationZ(bVar.ﾟ);
                        if (bVar.ᐧ) {
                            childAt.setElevation(bVar.ᐝˋ);
                        }
                    }
                }
            }
        }
        Iterator it = hashSet.iterator();
        while (it.hasNext()) {
            View barrier;
            Integer num = (Integer) it.next();
            b bVar2 = (b) this.ˊ.get(num);
            if (bVar2.ˊʼ != -1) {
                switch (bVar2.ˊʼ) {
                    case 1:
                        barrier = new Barrier(constraintLayout.getContext());
                        barrier.setId(num.intValue());
                        if (bVar2.ˉॱ != null) {
                            barrier.setReferencedIds(bVar2.ˉॱ);
                        } else if (bVar2.ʿॱ != null) {
                            bVar2.ˉॱ = ˊ(barrier, bVar2.ʿॱ);
                            barrier.setReferencedIds(bVar2.ˉॱ);
                        }
                        barrier.setType(bVar2.ˊʻ);
                        ViewGroup.LayoutParams ˎ = constraintLayout.ˎ();
                        barrier.ॱ();
                        bVar2.ˋ(ˎ);
                        constraintLayout.addView(barrier, ˎ);
                        break;
                }
            }
            if (bVar2.ˎ) {
                barrier = new Guideline(constraintLayout.getContext());
                barrier.setId(num.intValue());
                ViewGroup.LayoutParams ˎ2 = constraintLayout.ˎ();
                bVar2.ˋ(ˎ2);
                constraintLayout.addView(barrier, ˎ2);
            }
        }
    }

    public void ॱ(int i, int i2, int i3, int i4, int i5) {
        if (!this.ˊ.containsKey(Integer.valueOf(i))) {
            this.ˊ.put(Integer.valueOf(i), new b());
        }
        b bVar = (b) this.ˊ.get(Integer.valueOf(i));
        switch (i2) {
            case 1:
                if (i4 == 1) {
                    bVar.ʻ = i3;
                    bVar.ʽ = -1;
                } else if (i4 == 2) {
                    bVar.ʽ = i3;
                    bVar.ʻ = -1;
                } else {
                    throw new IllegalArgumentException("Left to " + ˋ(i4) + " undefined");
                }
                bVar.ˊᐝ = i5;
                return;
            case 2:
                if (i4 == 1) {
                    bVar.ʼ = i3;
                    bVar.ͺ = -1;
                } else if (i4 == 2) {
                    bVar.ͺ = i3;
                    bVar.ʼ = -1;
                } else {
                    throw new IllegalArgumentException("right to " + ˋ(i4) + " undefined");
                }
                bVar.ˎˎ = i5;
                return;
            case 3:
                if (i4 == 3) {
                    bVar.ˊॱ = i3;
                    bVar.ˋॱ = -1;
                    bVar.ॱˋ = -1;
                } else if (i4 == 4) {
                    bVar.ˋॱ = i3;
                    bVar.ˊॱ = -1;
                    bVar.ॱˋ = -1;
                } else {
                    throw new IllegalArgumentException("right to " + ˋ(i4) + " undefined");
                }
                bVar.ˌ = i5;
                return;
            case 4:
                if (i4 == 4) {
                    bVar.ˏॱ = i3;
                    bVar.ॱˊ = -1;
                    bVar.ॱˋ = -1;
                } else if (i4 == 3) {
                    bVar.ॱˊ = i3;
                    bVar.ˏॱ = -1;
                    bVar.ॱˋ = -1;
                } else {
                    throw new IllegalArgumentException("right to " + ˋ(i4) + " undefined");
                }
                bVar.ˍ = i5;
                return;
            case 5:
                if (i4 == 5) {
                    bVar.ॱˋ = i3;
                    bVar.ˏॱ = -1;
                    bVar.ॱˊ = -1;
                    bVar.ˊॱ = -1;
                    bVar.ˋॱ = -1;
                    return;
                }
                throw new IllegalArgumentException("right to " + ˋ(i4) + " undefined");
            case 6:
                if (i4 == 6) {
                    bVar.ॱᐝ = i3;
                    bVar.ʻॱ = -1;
                } else if (i4 == 7) {
                    bVar.ʻॱ = i3;
                    bVar.ॱᐝ = -1;
                } else {
                    throw new IllegalArgumentException("right to " + ˋ(i4) + " undefined");
                }
                bVar.ˋᐝ = i5;
                return;
            case 7:
                if (i4 == 7) {
                    bVar.ᐝॱ = i3;
                    bVar.ॱˎ = -1;
                } else if (i4 == 6) {
                    bVar.ॱˎ = i3;
                    bVar.ᐝॱ = -1;
                } else {
                    throw new IllegalArgumentException("right to " + ˋ(i4) + " undefined");
                }
                bVar.ˋˋ = i5;
                return;
            default:
                throw new IllegalArgumentException(ˋ(i2) + " to " + ˋ(i4) + " unknown");
        }
    }

    public void ˎ(int i, int i2) {
        ˎ(i).ˏˏ = i2;
    }

    public void ˊ(int i, int i2) {
        ˎ(i).ˏ = i2;
    }

    private b ˎ(int i) {
        if (!this.ˊ.containsKey(Integer.valueOf(i))) {
            this.ˊ.put(Integer.valueOf(i), new b());
        }
        return (b) this.ˊ.get(Integer.valueOf(i));
    }

    private String ˋ(int i) {
        switch (i) {
            case 1:
                return "left";
            case 2:
                return "right";
            case 3:
                return "top";
            case 4:
                return "bottom";
            case 5:
                return "baseline";
            case 6:
                return "start";
            case 7:
                return "end";
            default:
                return "undefined";
        }
    }

    public void ˊ(Context context, int i) {
        XmlPullParser xml = context.getResources().getXml(i);
        try {
            for (int eventType = xml.getEventType(); eventType != 1; eventType = xml.next()) {
                switch (eventType) {
                    case 0:
                        xml.getName();
                        break;
                    case 2:
                        String name = xml.getName();
                        b ˋ = ˋ(context, Xml.asAttributeSet(xml));
                        if (name.equalsIgnoreCase("Guideline")) {
                            ˋ.ˎ = true;
                        }
                        this.ˊ.put(Integer.valueOf(ˋ.ˋ), ˋ);
                        break;
                    default:
                        break;
                }
            }
        } catch (XmlPullParserException e) {
            e.printStackTrace();
        } catch (IOException e2) {
            e2.printStackTrace();
        }
    }

    private static int ˏ(TypedArray typedArray, int i, int i2) {
        int resourceId = typedArray.getResourceId(i, i2);
        if (resourceId == -1) {
            return typedArray.getInt(i, -1);
        }
        return resourceId;
    }

    private b ˋ(Context context, AttributeSet attributeSet) {
        b bVar = new b();
        TypedArray obtainStyledAttributes = context.obtainStyledAttributes(attributeSet, c.ʻᐝ);
        ˋ(bVar, obtainStyledAttributes);
        obtainStyledAttributes.recycle();
        return bVar;
    }

    private void ˋ(b bVar, TypedArray typedArray) {
        int indexCount = typedArray.getIndexCount();
        for (int i = 0; i < indexCount; i++) {
            int index = typedArray.getIndex(i);
            switch (ॱ.get(index)) {
                case 1:
                    bVar.ॱˋ = ˏ(typedArray, index, bVar.ॱˋ);
                    break;
                case 2:
                    bVar.ˍ = typedArray.getDimensionPixelSize(index, bVar.ˍ);
                    break;
                case 3:
                    bVar.ˏॱ = ˏ(typedArray, index, bVar.ˏॱ);
                    break;
                case 4:
                    bVar.ॱˊ = ˏ(typedArray, index, bVar.ॱˊ);
                    break;
                case 5:
                    bVar.ʼॱ = typedArray.getString(index);
                    break;
                case 6:
                    bVar.ˊˊ = typedArray.getDimensionPixelOffset(index, bVar.ˊˊ);
                    break;
                case 7:
                    bVar.ˊˋ = typedArray.getDimensionPixelOffset(index, bVar.ˊˋ);
                    break;
                case 8:
                    bVar.ˋˋ = typedArray.getDimensionPixelSize(index, bVar.ˋˋ);
                    break;
                case 9:
                    bVar.ᐝॱ = ˏ(typedArray, index, bVar.ᐝॱ);
                    break;
                case 10:
                    bVar.ॱˎ = ˏ(typedArray, index, bVar.ॱˎ);
                    break;
                case 11:
                    bVar.ˏˎ = typedArray.getDimensionPixelSize(index, bVar.ˏˎ);
                    break;
                case 12:
                    bVar.ـ = typedArray.getDimensionPixelSize(index, bVar.ـ);
                    break;
                case 13:
                    bVar.ˎˏ = typedArray.getDimensionPixelSize(index, bVar.ˎˏ);
                    break;
                case 14:
                    bVar.ͺॱ = typedArray.getDimensionPixelSize(index, bVar.ͺॱ);
                    break;
                case 15:
                    bVar.ॱͺ = typedArray.getDimensionPixelSize(index, bVar.ॱͺ);
                    break;
                case 16:
                    bVar.ˑ = typedArray.getDimensionPixelSize(index, bVar.ˑ);
                    break;
                case 17:
                    bVar.ˊ = typedArray.getDimensionPixelOffset(index, bVar.ˊ);
                    break;
                case 18:
                    bVar.ᐝ = typedArray.getDimensionPixelOffset(index, bVar.ᐝ);
                    break;
                case 19:
                    bVar.ॱॱ = typedArray.getFloat(index, bVar.ॱॱ);
                    break;
                case 20:
                    bVar.ʾ = typedArray.getFloat(index, bVar.ʾ);
                    break;
                case 21:
                    bVar.ॱ = typedArray.getLayoutDimension(index, bVar.ॱ);
                    break;
                case 22:
                    bVar.ˏˏ = typedArray.getInt(index, bVar.ˏˏ);
                    bVar.ˏˏ = ˋ[bVar.ˏˏ];
                    break;
                case 23:
                    bVar.ˏ = typedArray.getLayoutDimension(index, bVar.ˏ);
                    break;
                case 24:
                    bVar.ˊᐝ = typedArray.getDimensionPixelSize(index, bVar.ˊᐝ);
                    break;
                case 25:
                    bVar.ʻ = ˏ(typedArray, index, bVar.ʻ);
                    break;
                case 26:
                    bVar.ʽ = ˏ(typedArray, index, bVar.ʽ);
                    break;
                case 27:
                    bVar.ˋˊ = typedArray.getInt(index, bVar.ˋˊ);
                    break;
                case 28:
                    bVar.ˎˎ = typedArray.getDimensionPixelSize(index, bVar.ˎˎ);
                    break;
                case 29:
                    bVar.ʼ = ˏ(typedArray, index, bVar.ʼ);
                    break;
                case 30:
                    bVar.ͺ = ˏ(typedArray, index, bVar.ͺ);
                    break;
                case 31:
                    bVar.ˋᐝ = typedArray.getDimensionPixelSize(index, bVar.ˋᐝ);
                    break;
                case 32:
                    bVar.ʻॱ = ˏ(typedArray, index, bVar.ʻॱ);
                    break;
                case 33:
                    bVar.ॱᐝ = ˏ(typedArray, index, bVar.ॱᐝ);
                    break;
                case 34:
                    bVar.ˌ = typedArray.getDimensionPixelSize(index, bVar.ˌ);
                    break;
                case 35:
                    bVar.ˋॱ = ˏ(typedArray, index, bVar.ˋॱ);
                    break;
                case 36:
                    bVar.ˊॱ = ˏ(typedArray, index, bVar.ˊॱ);
                    break;
                case 37:
                    bVar.ʿ = typedArray.getFloat(index, bVar.ʿ);
                    break;
                case 38:
                    bVar.ˋ = typedArray.getResourceId(index, bVar.ˋ);
                    break;
                case 39:
                    bVar.ॱʼ = typedArray.getFloat(index, bVar.ॱʼ);
                    break;
                case 40:
                    bVar.ॱʽ = typedArray.getFloat(index, bVar.ॱʽ);
                    break;
                case 41:
                    bVar.ॱʻ = typedArray.getInt(index, bVar.ॱʻ);
                    break;
                case 42:
                    bVar.ᐨ = typedArray.getInt(index, bVar.ᐨ);
                    break;
                case 43:
                    bVar.ᐝᐝ = typedArray.getFloat(index, bVar.ᐝᐝ);
                    break;
                case 44:
                    bVar.ᐧ = true;
                    bVar.ᐝˋ = typedArray.getDimension(index, bVar.ᐝˋ);
                    break;
                case 45:
                    bVar.ꜟ = typedArray.getFloat(index, bVar.ꜟ);
                    break;
                case 46:
                    bVar.ᶥ = typedArray.getFloat(index, bVar.ᶥ);
                    break;
                case 47:
                    bVar.ꓸ = typedArray.getFloat(index, bVar.ꓸ);
                    break;
                case 48:
                    bVar.ꜞ = typedArray.getFloat(index, bVar.ꜞ);
                    break;
                case 49:
                    bVar.ㆍ = typedArray.getFloat(index, bVar.ㆍ);
                    break;
                case 50:
                    bVar.ꞌ = typedArray.getFloat(index, bVar.ꞌ);
                    break;
                case 51:
                    bVar.ﹳ = typedArray.getDimension(index, bVar.ﹳ);
                    break;
                case 52:
                    bVar.ʹ = typedArray.getDimension(index, bVar.ʹ);
                    break;
                case 53:
                    bVar.ﾟ = typedArray.getDimension(index, bVar.ﾟ);
                    break;
                case c.ᴵ /*60*/:
                    bVar.ᐝˊ = typedArray.getFloat(index, bVar.ᐝˊ);
                    break;
                case c.ᵢ /*61*/:
                    bVar.ʽॱ = ˏ(typedArray, index, bVar.ʽॱ);
                    break;
                case c.ⁱ /*62*/:
                    bVar.ˈ = typedArray.getDimensionPixelSize(index, bVar.ˈ);
                    break;
                case c.ㆍॱ /*63*/:
                    bVar.ˉ = typedArray.getFloat(index, bVar.ˉ);
                    break;
                case c.ꜟॱ /*69*/:
                    bVar.ʼᐝ = typedArray.getFloat(index, 1.0f);
                    break;
                case c.ꜝ /*70*/:
                    bVar.ʽᐝ = typedArray.getFloat(index, 1.0f);
                    break;
                case c.ﹳॱ /*71*/:
                    Log.e("ConstraintSet", "CURRENTLY UNSUPPORTED");
                    break;
                case 72:
                    bVar.ˊʻ = typedArray.getInt(index, bVar.ˊʻ);
                    break;
                case c.ﹶ /*73*/:
                    bVar.ʿॱ = typedArray.getString(index);
                    break;
                case c.ʳ /*74*/:
                    bVar.ʽˋ = typedArray.getBoolean(index, bVar.ʽˋ);
                    break;
                case c.ﾞॱ /*75*/:
                    Log.w("ConstraintSet", "unused attribute 0x" + Integer.toHexString(index) + "   " + ॱ.get(index));
                    break;
                default:
                    Log.w("ConstraintSet", "Unknown attribute 0x" + Integer.toHexString(index) + "   " + ॱ.get(index));
                    break;
            }
        }
    }

    private int[] ˊ(View view, String str) {
        String[] split = str.split(",");
        Context context = view.getContext();
        int[] iArr = new int[split.length];
        int i = 0;
        int i2 = 0;
        while (i < split.length) {
            int i3;
            int intValue;
            String trim = split[i].trim();
            try {
                i3 = e.class.getField(trim).getInt(null);
            } catch (Exception e) {
                i3 = 0;
            }
            if (i3 == 0) {
                i3 = context.getResources().getIdentifier(trim, "id", context.getPackageName());
            }
            if (i3 == 0 && view.isInEditMode() && (view.getParent() instanceof ConstraintLayout)) {
                Object ˋ = ((ConstraintLayout) view.getParent()).ˋ(0, trim);
                if (ˋ != null && (ˋ instanceof Integer)) {
                    intValue = ((Integer) ˋ).intValue();
                    i3 = i2 + 1;
                    iArr[i2] = intValue;
                    i++;
                    i2 = i3;
                }
            }
            intValue = i3;
            i3 = i2 + 1;
            iArr[i2] = intValue;
            i++;
            i2 = i3;
        }
        if (i2 != split.length) {
            return Arrays.copyOf(iArr, i2);
        }
        return iArr;
    }
}
